The development of the computer era began in the 1940's. Since that time, computers and computer systems have evolved into extremely sophisticated devices, and computer systems that can be found in many different settings. Computer systems typically include a combination of hardware, such as semiconductors and circuit boards, and software, also known as computer programs. As advances in semiconductor processing and computer architecture push the performance of the computer hardware higher, more sophisticated computer software has evolved to take advantage of the higher performance of the hardware, resulting in computer systems today that are much more powerful than just a few years ago.
Computer systems typically include operating system software that controls the basic function of the computer, and one or more software application programs that run under the control of the operating system to perform desired tasks. For example, a typical IBM Personal Computer may run the OS/2 operating system, and under the control of the OS/2 operating system, a user may execute an application program, such as a word processor. As the capabilities of computer systems have increased, the application software programs designed for high performance computer systems have become extremely powerful. Additionally, software development costs have continued to rise because more powerful and complex programs take more time, and hence more money, to produce.
One way in which the performance of application software programs has been improved while the associated development costs have been reduced is by using object oriented programming concepts. The goal of using object oriented programming is to create small, reusable sections of program code known as “objects” that can be quickly and easily combined and re-used to create new programs. This concept is similar to the idea of using the same set of building blocks again and again to create many different structures. The modular and re-usable aspects of objects will typically speed development of new programs, thereby reducing the costs associated with the development cycle. In addition, by creating and re-using a comprehensive set of well-tested objects, one can achieve a more stable, uniform, and consistent approach to developing new computer programs.
A central concept in object-oriented programming is the “class.” A class is a template that defines a type of object. A class outlines or describes the characteristics or makeup of objects that belong to that class. By defining a class, objects can be created that belong to the class without having to rewrite the entire definition for each new object. This feature of object-oriented programming promotes the reusability of existing object definitions and promotes more efficient use of program code.
Modern object oriented programming languages have features that improve the convenience of programming in those languages. For example, the Java programming language developed by Sun Microsystems has a garbage collection feature that automatically disposes of objects that are no longer used. This automatic garbage collection takes away from the programmer the burden of tracking which objects are used and which are not, and disposing of objects that are no longer used.
Object oriented programming is a method of program implementation in which programs are organized as cooperative collections of objects, each of which represents an instance of some class, and whose classes are all members of a hierarchy of classes united via inheritance relationships. Object oriented programming differs from standard procedural programming in that it uses objects, not algorithms, as the fundamental building blocks for creating computer programs. This difference stems from the fact that the design focus of object oriented programming technology is wholly different than that of procedural programming technology.
The focus of procedural-based design is on the overall process used to solve the problem; whereas the focus of object oriented design is on casting the problem as a set of autonomous entities that can work together to provide a solution. The autonomous entities of object-oriented technology are, of course, objects. Object oriented technology is significantly different from procedural technology because problems are broken down into sets of cooperating objects instead of into hierarchies of nested computer programs or procedures.
Thus, a pure object oriented program is made up of code entities called objects. Each object is an identifiable, encapsulated piece of code and data that provides one or more services when requested by a client. Conceptually, an object has two parts, an external object interface and internal object implementation. In particular, all object implementation functions are encapsulated by the object interface such that other objects must communicate with that object through its object interface. The only way to retrieve, process or otherwise operate on the object is through the methods defined on the object. This protects the internal data portion of the object from outside tampering. Additionally, because outside objects have no access to the internal implementation, that internal implementation can change without affecting other aspects of the program.
In this way, the object system isolates the requestor of services (client objects) from the providers of services (server objects) by a well-defined encapsulating interface. In the classic object model, a client object sends request messages to server objects to perform any necessary or desired function. The message identifies a specific method to be performed by the server object, and also supplies any required parameters. The server object receives and interprets the message, and can then decide what operations to perform.
Many of these objects are implemented in programs that are long running processes such as web processes or business transaction processes. These programs exist in environments where many people will access these programs. In these applications programs, the objects can contain information for these long running processes. At some point, the information will become stale and there will be a need to refresh/update the information. However, at the point when it is necessary to refresh this information, it is not known what other processes are using/referencing this information. Presently, if the object began to refresh the information, any processes referencing the object program would lose the connection to the object program. The loss of the connection would result in a processing failure for the referencing program. In addition, the user would then need to repeat the process that they originally followed to find the object and information. To prevent this situation, a system programmer has to put special instructions in place in the program. The insertion of special instructions is a difficult and problematic process. However, without these special instructions the user gets errors in the information.
Therefore, there remains a need for a method that can preserve the reference connections to these objects in long running processes when it is necessary to refresh information contained in these objects. This method would provide accuracy of information in these objects and would address the current problems associated with loss connections resulting from object re-initialization.